home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / fax / src / libtiff / tif_dir.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  26KB  |  962 lines
  1. #ifndef lint
  2. static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_dir.c,v 1.124 93/06/28 16:16:14 sam Exp $";
  3. #endif
  4.  
  5. /*
  6.  * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
  7.  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and 
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  * 
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20.  * 
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library.
  31.  *
  32.  * Directory Tag Get & Set Routines.
  33.  * (and also some miscellaneous stuff)
  34.  *
  35.  * NB: Beware of the varargs declarations for routines in
  36.  *     this file.  The names and types of variables has been
  37.  *     carefully chosen to make things work with compilers that
  38.  *     are busted in one way or another (e.g. SGI/MIPS).
  39.  */
  40. #include "tiffiop.h"
  41.  
  42. static
  43. DECLARE2(setString, char**, cpp, char*, cp)
  44. {
  45.     if (*cpp)
  46.         _TIFFfree(*cpp), *cpp = 0;
  47.     if (cp) {
  48.         int len = strlen(cp)+1;
  49.         if (*cpp = _TIFFmalloc(len))
  50.             memcpy(*cpp, cp, len);
  51.     }
  52. }
  53.  
  54. static
  55. DECLARE3(setShortArray, u_short**, wpp, u_short*, wp, long, n)
  56. {
  57.     if (*wpp)
  58.         _TIFFfree((char *)*wpp), *wpp = 0;
  59.     n *= sizeof (u_short);
  60.     if (wp && (*wpp = (u_short *)_TIFFmalloc(n)))
  61.         memcpy(*wpp, wp, n);
  62. }
  63.  
  64. static
  65. DECLARE3(setLongArray, u_long**, wpp, u_long*, wp, long, n)
  66. {
  67.     if (*wpp)
  68.         _TIFFfree((char *)*wpp), *wpp = 0;
  69.     n *= sizeof (u_long);
  70.     if (wp && (*wpp = (u_long *)_TIFFmalloc(n)))
  71.         memcpy(*wpp, wp, n);
  72. }
  73.  
  74. static
  75. DECLARE3(setFloatArray, float**, wpp, float*, wp, long, n)
  76. {
  77.     if (*wpp)
  78.         _TIFFfree((char *)*wpp), *wpp = 0;
  79.     n *= sizeof (float);
  80.     if (wp && (*wpp = (float *)_TIFFmalloc(n)))
  81.         memcpy(*wpp, wp, n);
  82. }
  83.  
  84. #ifdef JPEG_SUPPORT
  85. /*
  86.  * Install a JPEG Quantization table.
  87.  * Note that we reorder the elements
  88.  * of the array in the zig-zag order
  89.  * that is expected by the compression code
  90.  * and that is to be stored in the file.
  91.  */
  92. static
  93. DECLARE3(setJPEGQTable, u_char***, wpp, u_char**, wp, int, nc)
  94. {
  95.     static u_char zigzag[64] = {
  96.         0,  1,  5,  6, 14, 15, 27, 28,
  97.         2,  4,  7, 13, 16, 26, 29, 42,
  98.         3,  8, 12, 17, 25, 30, 41, 43,
  99.         9, 11, 18, 24, 31, 40, 44, 53,
  100.        10, 19, 23, 32, 39, 45, 52, 54,
  101.        20, 22, 33, 38, 46, 51, 55, 60,
  102.        21, 34, 37, 47, 50, 56, 59, 61,
  103.        35, 36, 48, 49, 57, 58, 62, 63
  104.     };
  105.     char *tab;
  106.     int i, j;
  107.  
  108.     if (*wpp)
  109.         _TIFFfree((char *)*wpp), *wpp = 0;
  110.     *wpp = (u_char **)
  111.         _TIFFmalloc(nc * (sizeof (u_char *) + 64*sizeof (u_char)));
  112.     tab = (((char *)*wpp) + nc*sizeof (u_short *));
  113.     for (i = 0; i < nc; i++) {
  114.         (*wpp)[i] = (u_char *)tab;
  115.         for (j = 0; j < 64; j++)
  116.             tab[zigzag[j]] = wp[i][j];
  117.         tab += 64*sizeof (u_char);
  118.     }
  119. }
  120.  
  121. /*
  122.  * Install a JPEG Coefficient table.
  123.  */
  124. static
  125. DECLARE3(setJPEGCTable, u_char***, cpp, u_char**, cp, int, nc)
  126. {
  127.     u_char *tab;
  128.     int i, j, nw;
  129.  
  130.     if (*cpp)
  131.         _TIFFfree(*cpp), *cpp = 0;
  132.     /*
  133.      * Calculate the size of the table by counting
  134.      * the number of codes specified in the bits array.
  135.      */
  136.     nw = 0;
  137.     for (i = 0; i < nc; i++) {
  138.         nw += 16;        /* 16 bytes for bits array */
  139.         for (j = 0; j < 16; j++)/* sum up count of codes */
  140.             nw += cp[i][j];
  141.     }
  142.     *cpp = (u_char **)_TIFFmalloc(nc*sizeof (u_char *) + nw);
  143.     tab = ((u_char *)*cpp) + nc*sizeof (u_char *);
  144.     /*
  145.      * Setup internal array and copy user data.
  146.      */
  147.     for (i = 0; i < nc; i++) {
  148.         (*cpp)[i] = tab;
  149.         for (nw = 16, j = 0; j < 16; j++)
  150.             nw += cp[i][j];
  151.         memcpy(tab, cp[i], nw);
  152.         tab += nw;
  153.     }
  154. }
  155. #endif
  156.  
  157. static
  158. DECLARE3(TIFFSetField1, TIFF*, tif, u_int, tag, va_list, ap)
  159. {
  160.     TIFFDirectory *td = &tif->tif_dir;
  161.     int i, status = 1;
  162.     long v;
  163.  
  164.     switch (tag) {
  165.     case TIFFTAG_SUBFILETYPE:
  166.         td->td_subfiletype = va_arg(ap, u_long);
  167.         break;
  168.     case TIFFTAG_IMAGEWIDTH:
  169.         td->td_imagewidth = va_arg(ap, u_long);
  170.         break;
  171.     case TIFFTAG_IMAGELENGTH:
  172.         td->td_imagelength = va_arg(ap, u_long);
  173.         break;
  174.     case TIFFTAG_BITSPERSAMPLE:
  175.         td->td_bitspersample = va_arg(ap, int);
  176.         break;
  177.     case TIFFTAG_COMPRESSION:
  178.         v = va_arg(ap, int) & 0xffff;
  179.         /*
  180.          * If we're changing the compression scheme,
  181.          * the notify the previous module so that it
  182.          * can cleanup any state it's setup.
  183.          */
  184.         if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
  185.             if (td->td_compression == v)
  186.                 break;
  187.             if (tif->tif_cleanup)
  188.                 (*tif->tif_cleanup)(tif);
  189.         }
  190.         /*
  191.          * Setup new compression routine state.
  192.          */
  193.         if (status = TIFFSetCompressionScheme(tif, v))
  194.             td->td_compression = v;
  195.         break;
  196.     case TIFFTAG_PHOTOMETRIC:
  197.         td->td_photometric = va_arg(ap, int);
  198.         break;
  199.     case TIFFTAG_THRESHHOLDING:
  200.         td->td_threshholding = va_arg(ap, int);
  201.         break;
  202.     case TIFFTAG_FILLORDER:
  203.         v = va_arg(ap, int);
  204.         if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
  205.             goto badvalue;
  206.         td->td_fillorder = v;
  207.         break;
  208.     case TIFFTAG_DOCUMENTNAME:
  209.         setString(&td->td_documentname, va_arg(ap, char *));
  210.         break;
  211.     case TIFFTAG_ARTIST:
  212.         setString(&td->td_artist, va_arg(ap, char *));
  213.         break;
  214.     case TIFFTAG_DATETIME:
  215.         setString(&td->td_datetime, va_arg(ap, char *));
  216.         break;
  217.     case TIFFTAG_HOSTCOMPUTER:
  218.         setString(&td->td_hostcomputer, va_arg(ap, char *));
  219.         break;
  220.     case TIFFTAG_IMAGEDESCRIPTION:
  221.         setString(&td->td_imagedescription, va_arg(ap, char *));
  222.         break;
  223.     case TIFFTAG_MAKE:
  224.         setString(&td->td_make, va_arg(ap, char *));
  225.         break;
  226.     case TIFFTAG_MODEL:
  227.         setString(&td->td_model, va_arg(ap, char *));
  228.         break;
  229.     case TIFFTAG_SOFTWARE:
  230.         setString(&td->td_software, va_arg(ap, char *));
  231.         break;
  232.     case TIFFTAG_ORIENTATION:
  233.         v = va_arg(ap, int);
  234.         if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
  235.             TIFFWarning(tif->tif_name,
  236.                 "Bad value %ld for \"%s\" tag ignored",
  237.                 v, TIFFFieldWithTag(tag)->field_name);
  238.         } else
  239.             td->td_orientation = v;
  240.         break;
  241.     case TIFFTAG_SAMPLESPERPIXEL:
  242.         /* XXX should cross check -- e.g. if pallette, then 1 */
  243.         v = va_arg(ap, int);
  244.         if (v == 0)
  245.             goto badvalue;
  246.         td->td_samplesperpixel = v;
  247.         break;
  248.     case TIFFTAG_ROWSPERSTRIP:
  249.         v = va_arg(ap, u_long);
  250.         if (v == 0)
  251.             goto badvalue;
  252.         td->td_rowsperstrip = v;
  253.         if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  254.             td->td_tilelength = v;
  255.             td->td_tilewidth = td->td_imagewidth;
  256.         }
  257.         break;
  258.     case TIFFTAG_MINSAMPLEVALUE:
  259.         td->td_minsamplevalue = va_arg(ap, int) & 0xffff;
  260.         break;
  261.     case TIFFTAG_MAXSAMPLEVALUE:
  262.         td->td_maxsamplevalue = va_arg(ap, int) & 0xffff;
  263.         break;
  264.     case TIFFTAG_XRESOLUTION:
  265.         td->td_xresolution = va_arg(ap, dblparam_t);
  266.         break;
  267.     case TIFFTAG_YRESOLUTION:
  268.         td->td_yresolution = va_arg(ap, dblparam_t);
  269.         break;
  270.     case TIFFTAG_PLANARCONFIG:
  271.         v = va_arg(ap, int);
  272.         if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
  273.             goto badvalue;
  274.         td->td_planarconfig = v;
  275.         break;
  276.     case TIFFTAG_PAGENAME:
  277.         setString(&td->td_pagename, va_arg(ap, char *));
  278.         break;
  279.     case TIFFTAG_XPOSITION:
  280.         td->td_xposition = va_arg(ap, dblparam_t);
  281.         break;
  282.     case TIFFTAG_YPOSITION:
  283.         td->td_yposition = va_arg(ap, dblparam_t);
  284.         break;
  285.     case TIFFTAG_GROUP3OPTIONS:
  286.         td->td_group3options = va_arg(ap, u_long);
  287.         break;
  288.     case TIFFTAG_GROUP4OPTIONS:
  289.         td->td_group4options = va_arg(ap, u_long);
  290.         break;
  291.     case TIFFTAG_RESOLUTIONUNIT:
  292.         v = va_arg(ap, int);
  293.         if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
  294.             goto badvalue;
  295.         td->td_resolutionunit = v;
  296.         break;
  297.     case TIFFTAG_PAGENUMBER:
  298.         td->td_pagenumber[0] = va_arg(ap, int);
  299.         td->td_pagenumber[1] = va_arg(ap, int);
  300.         break;
  301.     case TIFFTAG_HALFTONEHINTS:
  302.         td->td_halftonehints[0] = va_arg(ap, int);
  303.         td->td_halftonehints[1] = va_arg(ap, int);
  304.         break;
  305.     case TIFFTAG_COLORMAP:
  306.         v = 1L<<td->td_bitspersample;
  307.         setShortArray(&td->td_colormap[0], va_arg(ap, u_short *), v);
  308.         setShortArray(&td->td_colormap[1], va_arg(ap, u_short *), v);
  309.         setShortArray(&td->td_colormap[2], va_arg(ap, u_short *), v);
  310.         break;
  311.     case TIFFTAG_PREDICTOR:
  312.         td->td_predictor = va_arg(ap, int);
  313.         break;
  314.     case TIFFTAG_EXTRASAMPLES:
  315.         v = va_arg(ap, int);
  316.         if (v > td->td_samplesperpixel)
  317.             goto badvalue;
  318.         if (v != 1)            /* XXX */
  319.             goto badvalue;        /* XXX */
  320.         v = va_arg(ap, int);
  321.         if (v != EXTRASAMPLE_ASSOCALPHA)/* XXX */
  322.             goto badvalue;        /* XXX */
  323.         td->td_matteing = 1;
  324.         break;
  325.     case TIFFTAG_MATTEING:
  326.         td->td_matteing = va_arg(ap, int);
  327.         break;
  328.     case TIFFTAG_BADFAXLINES:
  329.         td->td_badfaxlines = va_arg(ap, u_long);
  330.         break;
  331.     case TIFFTAG_CLEANFAXDATA:
  332.         td->td_cleanfaxdata = va_arg(ap, int);
  333.         break;
  334.     case TIFFTAG_CONSECUTIVEBADFAXLINES:
  335.         td->td_badfaxrun = va_arg(ap, u_long);
  336.         break;
  337.     case TIFFTAG_TILEWIDTH:
  338.         v = va_arg(ap, u_long);
  339.         if (v % 16)
  340.             goto badvalue;
  341.         td->td_tilewidth = v;
  342.         tif->tif_flags |= TIFF_ISTILED;
  343.         break;
  344.     case TIFFTAG_TILELENGTH:
  345.         v = va_arg(ap, u_long);
  346.         if (v % 16)
  347.             goto badvalue;
  348.         td->td_tilelength = v;
  349.         tif->tif_flags |= TIFF_ISTILED;
  350.         break;
  351.     case TIFFTAG_TILEDEPTH:
  352.         v = va_arg(ap, u_long);
  353.         if (v == 0)
  354.             goto badvalue;
  355.         td->td_tiledepth = v;
  356.         break;
  357.     case TIFFTAG_DATATYPE:
  358.     case TIFFTAG_SAMPLEFORMAT:
  359.         v = va_arg(ap, int);
  360.         if (tag == TIFFTAG_DATATYPE && v == 0)
  361.             v = SAMPLEFORMAT_VOID;
  362.         if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_VOID < v)
  363.             goto badvalue;
  364.         td->td_sampleformat = v;
  365.         break;
  366.     case TIFFTAG_IMAGEDEPTH:
  367.         td->td_imagedepth = va_arg(ap, u_long);
  368.         break;
  369. #ifdef YCBCR_SUPPORT
  370.     case TIFFTAG_YCBCRCOEFFICIENTS:
  371.         setFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float *), 3);
  372.         break;
  373.     case TIFFTAG_YCBCRPOSITIONING:
  374.         td->td_ycbcrpositioning = va_arg(ap, int);
  375.         break;
  376.     case TIFFTAG_YCBCRSUBSAMPLING:
  377.         td->td_ycbcrsubsampling[0] = va_arg(ap, int);
  378.         td->td_ycbcrsubsampling[1] = va_arg(ap, int);
  379.         break;
  380. #endif
  381. #ifdef JPEG_SUPPORT
  382.     case TIFFTAG_JPEGPROC:
  383.         td->td_jpegproc = va_arg(ap, int);
  384.         break;
  385.     case TIFFTAG_JPEGRESTARTINTERVAL:
  386.         td->td_jpegrestartinterval = va_arg(ap, int);
  387.         break;
  388.     case TIFFTAG_JPEGQTABLES:
  389.         setJPEGQTable(&td->td_qtab, va_arg(ap, u_char **),
  390.             td->td_samplesperpixel);
  391.         break;
  392.     case TIFFTAG_JPEGDCTABLES:
  393.         setJPEGCTable(&td->td_dctab, va_arg(ap, u_char **),
  394.             td->td_samplesperpixel);
  395.         break;
  396.     case TIFFTAG_JPEGACTABLES:
  397.         setJPEGCTable(&td->td_actab, va_arg(ap, u_char **),
  398.             td->td_samplesperpixel);
  399.         break;
  400. #endif
  401. #ifdef COLORIMETRY_SUPPORT
  402.     case TIFFTAG_WHITEPOINT:
  403.         setFloatArray(&td->td_whitepoint, va_arg(ap, float *), 2);
  404.         break;
  405.     case TIFFTAG_PRIMARYCHROMATICITIES:
  406.         setFloatArray(&td->td_primarychromas, va_arg(ap, float *), 6);
  407.         break;
  408.     case TIFFTAG_TRANSFERFUNCTION:
  409.         v = (td->td_samplesperpixel - td->td_matteing) > 1 ? 3 : 1;
  410.         for (i = 0; i < v; i++)
  411.             setShortArray(&td->td_transferfunction[i],
  412.             va_arg(ap, u_short *), 1L<<td->td_bitspersample);
  413.         break;
  414.     case TIFFTAG_REFERENCEBLACKWHITE:
  415.         /* XXX should check for null range */
  416.         setFloatArray(&td->td_refblackwhite, va_arg(ap, float *), 6);
  417.         break;
  418. #endif
  419. #ifdef CMYK_SUPPORT
  420.     case TIFFTAG_INKSET:
  421.         td->td_inkset = va_arg(ap, int);
  422.         break;
  423.     case TIFFTAG_DOTRANGE:
  424.         /* XXX should check for null range */
  425.         td->td_dotrange[0] = va_arg(ap, int);
  426.         td->td_dotrange[1] = va_arg(ap, int);
  427.         break;
  428.     case TIFFTAG_INKNAMES:
  429.         setString(&td->td_inknames, va_arg(ap, char *));
  430.         break;
  431.     case TIFFTAG_TARGETPRINTER:
  432.         setString(&td->td_targetprinter, va_arg(ap, char *));
  433.         break;
  434. #endif
  435.     default:
  436.         TIFFError(tif->tif_name,
  437.             "Internal error, tag value botch, tag \"%s\"",
  438.             TIFFFieldWithTag(tag)->field_name);
  439.         status = 0;
  440.         break;
  441.     }
  442.     if (status) {
  443.         TIFFSetFieldBit(tif, TIFFFieldWithTag(tag)->field_bit);
  444.         tif->tif_flags |= TIFF_DIRTYDIRECT;
  445.     }
  446.     va_end(ap);
  447.     return (status);
  448. badvalue:
  449.     TIFFError(tif->tif_name, "%ld: Bad value for \"%s\"", v,
  450.         TIFFFieldWithTag(tag)->field_name);
  451.     va_end(ap);
  452.     return (0);
  453. }
  454.  
  455. /*
  456.  * Return 1/0 according to whether or not
  457.  * it is permissible to set the tag's value.
  458.  * Note that we allow ImageLength to be changed
  459.  * so that we can append and extend to images.
  460.  * Any other tag may not be altered once writing
  461.  * has commenced, unless its value has no effect
  462.  * on the format of the data that is written.
  463.  */
  464. static
  465. DECLARE2(OkToChangeTag, TIFF*, tif, u_int, tag)
  466. {
  467.     if (tag != TIFFTAG_IMAGELENGTH &&
  468.         (tif->tif_flags & TIFF_BEENWRITING)) {
  469.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  470.         /*
  471.          * Consult info table to see if tag can be changed
  472.          * after we've started writing.  We only allow changes
  473.          * to those tags that don't/shouldn't affect the
  474.          * compression and/or format of the data.
  475.          */
  476.         if (fip && !fip->field_oktochange)
  477.             return (0);
  478.     }
  479.     return (1);
  480. }
  481.  
  482. /*
  483.  * Record the value of a field in the
  484.  * internal directory structure.  The
  485.  * field will be written to the file
  486.  * when/if the directory structure is
  487.  * updated.
  488.  */
  489. /*VARARGS2*/
  490. DECLARE2V(TIFFSetField, TIFF*, tif, u_int, tag)
  491. {
  492.     int status = 0;
  493.  
  494.     if (OkToChangeTag(tif, tag)) {
  495.         va_list ap;
  496.  
  497.         VA_START(ap, tag);
  498.         status = TIFFSetField1(tif, tag, ap);
  499.         va_end(ap);
  500.     } else {
  501.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  502.         if (fip)
  503.             TIFFError("TIFFSetField",
  504.                 "%s: Cannot modify tag \"%s\" while writing",
  505.                 tif->tif_name, fip->field_name);
  506.     }
  507.     return (status);
  508. }
  509.  
  510. /*
  511.  * Like TIFFSetField, but taking a varargs
  512.  * parameter list.  This routine is useful
  513.  * for building higher-level interfaces on
  514.  * top of the library.
  515.  */
  516. int
  517. DECLARE3(TIFFVSetField, TIFF*, tif, u_int, tag, va_list, ap)
  518. {
  519.     int status = 0;
  520.  
  521.     if (!OkToChangeTag(tif, tag)) {
  522.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  523.         if (fip)
  524.             TIFFError("TIFFVSetField",
  525.                 "%s: Cannot modify tag \"%s\" while writing",
  526.                 tif->tif_name, fip->field_name);
  527.     } else
  528.         status = TIFFSetField1(tif, tag, ap);
  529.     return (status);
  530. }
  531.  
  532. static
  533. DECLARE3(TIFFGetField1, TIFFDirectory*, td, u_int, tag, va_list, ap)
  534. {
  535.  
  536.     switch (tag) {
  537.     case TIFFTAG_SUBFILETYPE:
  538.         *va_arg(ap, u_long *) = td->td_subfiletype;
  539.         break;
  540.     case TIFFTAG_IMAGEWIDTH:
  541.         *va_arg(ap, u_long *) = td->td_imagewidth;
  542.         break;
  543.     case TIFFTAG_IMAGELENGTH:
  544.         *va_arg(ap, u_long *) = td->td_imagelength;
  545.         break;
  546.     case TIFFTAG_BITSPERSAMPLE:
  547.         *va_arg(ap, u_short *) = td->td_bitspersample;
  548.         break;
  549.     case TIFFTAG_COMPRESSION:
  550.         *va_arg(ap, u_short *) = td->td_compression;
  551.         break;
  552.     case TIFFTAG_PHOTOMETRIC:
  553.         *va_arg(ap, u_short *) = td->td_photometric;
  554.         break;
  555.     case TIFFTAG_THRESHHOLDING:
  556.         *va_arg(ap, u_short *) = td->td_threshholding;
  557.         break;
  558.     case TIFFTAG_FILLORDER:
  559.         *va_arg(ap, u_short *) = td->td_fillorder;
  560.         break;
  561.     case TIFFTAG_DOCUMENTNAME:
  562.         *va_arg(ap, char **) = td->td_documentname;
  563.         break;
  564.     case TIFFTAG_ARTIST:
  565.         *va_arg(ap, char **) = td->td_artist;
  566.         break;
  567.     case TIFFTAG_DATETIME:
  568.         *va_arg(ap, char **) = td->td_datetime;
  569.         break;
  570.     case TIFFTAG_HOSTCOMPUTER:
  571.         *va_arg(ap, char **) = td->td_hostcomputer;
  572.         break;
  573.     case TIFFTAG_IMAGEDESCRIPTION:
  574.         *va_arg(ap, char **) = td->td_imagedescription;
  575.         break;
  576.     case TIFFTAG_MAKE:
  577.         *va_arg(ap, char **) = td->td_make;
  578.         break;
  579.     case TIFFTAG_MODEL:
  580.         *va_arg(ap, char **) = td->td_model;
  581.         break;
  582.     case TIFFTAG_SOFTWARE:
  583.         *va_arg(ap, char **) = td->td_software;
  584.         break;
  585.     case TIFFTAG_ORIENTATION:
  586.         *va_arg(ap, u_short *) = td->td_orientation;
  587.         break;
  588.     case TIFFTAG_SAMPLESPERPIXEL:
  589.         *va_arg(ap, u_short *) = td->td_samplesperpixel;
  590.         break;
  591.     case TIFFTAG_ROWSPERSTRIP:
  592.         *va_arg(ap, u_long *) = td->td_rowsperstrip;
  593.         break;
  594.     case TIFFTAG_MINSAMPLEVALUE:
  595.         *va_arg(ap, u_short *) = td->td_minsamplevalue;
  596.         break;
  597.     case TIFFTAG_MAXSAMPLEVALUE:
  598.         *va_arg(ap, u_short *) = td->td_maxsamplevalue;
  599.         break;
  600.     case TIFFTAG_XRESOLUTION:
  601.         *va_arg(ap, float *) = td->td_xresolution;
  602.         break;
  603.     case TIFFTAG_YRESOLUTION:
  604.         *va_arg(ap, float *) = td->td_yresolution;
  605.         break;
  606.     case TIFFTAG_PLANARCONFIG:
  607.         *va_arg(ap, u_short *) = td->td_planarconfig;
  608.         break;
  609.     case TIFFTAG_XPOSITION:
  610.         *va_arg(ap, float *) = td->td_xposition;
  611.         break;
  612.     case TIFFTAG_YPOSITION:
  613.         *va_arg(ap, float *) = td->td_yposition;
  614.         break;
  615.     case TIFFTAG_PAGENAME:
  616.         *va_arg(ap, char **) = td->td_pagename;
  617.         break;
  618.     case TIFFTAG_GROUP3OPTIONS:
  619.         *va_arg(ap, u_long *) = td->td_group3options;
  620.         break;
  621.     case TIFFTAG_GROUP4OPTIONS:
  622.         *va_arg(ap, u_long *) = td->td_group4options;
  623.         break;
  624.     case TIFFTAG_RESOLUTIONUNIT:
  625.         *va_arg(ap, u_short *) = td->td_resolutionunit;
  626.         break;
  627.     case TIFFTAG_PAGENUMBER:
  628.         *va_arg(ap, u_short *) = td->td_pagenumber[0];
  629.         *va_arg(ap, u_short *) = td->td_pagenumber[1];
  630.         break;
  631.     case TIFFTAG_HALFTONEHINTS:
  632.         *va_arg(ap, u_short *) = td->td_halftonehints[0];
  633.         *va_arg(ap, u_short *) = td->td_halftonehints[1];
  634.         break;
  635.     case TIFFTAG_COLORMAP:
  636.         *va_arg(ap, u_short **) = td->td_colormap[0];
  637.         *va_arg(ap, u_short **) = td->td_colormap[1];
  638.         *va_arg(ap, u_short **) = td->td_colormap[2];
  639.         break;
  640.     case TIFFTAG_PREDICTOR:
  641.         *va_arg(ap, u_short *) = td->td_predictor;
  642.         break;
  643.     case TIFFTAG_STRIPOFFSETS:
  644.     case TIFFTAG_TILEOFFSETS:
  645.         *va_arg(ap, u_long **) = td->td_stripoffset;
  646.         break;
  647.     case TIFFTAG_STRIPBYTECOUNTS:
  648.     case TIFFTAG_TILEBYTECOUNTS:
  649.         *va_arg(ap, u_long **) = td->td_stripbytecount;
  650.         break;
  651.     case TIFFTAG_MATTEING:
  652.         *va_arg(ap, u_short *) = td->td_matteing;
  653.         break;
  654.     case TIFFTAG_EXTRASAMPLES:
  655.         *va_arg(ap, u_short *) = td->td_matteing;
  656.         *va_arg(ap, u_short **) = &td->td_matteing;
  657.         break;
  658.     case TIFFTAG_BADFAXLINES:
  659.         *va_arg(ap, u_long *) = td->td_badfaxlines;
  660.         break;
  661.     case TIFFTAG_CLEANFAXDATA:
  662.         *va_arg(ap, u_short *) = td->td_cleanfaxdata;
  663.         break;
  664.     case TIFFTAG_CONSECUTIVEBADFAXLINES:
  665.         *va_arg(ap, u_long *) = td->td_badfaxrun;
  666.         break;
  667.     case TIFFTAG_TILEWIDTH:
  668.         *va_arg(ap, u_long *) = td->td_tilewidth;
  669.         break;
  670.     case TIFFTAG_TILELENGTH:
  671.         *va_arg(ap, u_long *) = td->td_tilelength;
  672.         break;
  673.     case TIFFTAG_TILEDEPTH:
  674.         *va_arg(ap, u_long *) = td->td_tiledepth;
  675.         break;
  676.     case TIFFTAG_DATATYPE:
  677.         *va_arg(ap, u_short *) =
  678.             (td->td_sampleformat == SAMPLEFORMAT_VOID ?
  679.             0 : td->td_sampleformat);
  680.         break;
  681.     case TIFFTAG_SAMPLEFORMAT:
  682.         *va_arg(ap, u_short *) = td->td_sampleformat;
  683.         break;
  684.     case TIFFTAG_IMAGEDEPTH:
  685.         *va_arg(ap, u_long *) = td->td_imagedepth;
  686.         break;
  687. #ifdef YCBCR_SUPPORT
  688.     case TIFFTAG_YCBCRCOEFFICIENTS:
  689.         *va_arg(ap, float **) = td->td_ycbcrcoeffs;
  690.         break;
  691.     case TIFFTAG_YCBCRPOSITIONING:
  692.         *va_arg(ap, u_short *) = td->td_ycbcrpositioning;
  693.         break;
  694.     case TIFFTAG_YCBCRSUBSAMPLING:
  695.         *va_arg(ap, u_short *) = td->td_ycbcrsubsampling[0];
  696.         *va_arg(ap, u_short *) = td->td_ycbcrsubsampling[1];
  697.         break;
  698. #endif
  699. #ifdef JPEG_SUPPORT
  700.     case TIFFTAG_JPEGPROC:
  701.         *va_arg(ap, u_short *) = td->td_jpegproc;
  702.         break;
  703.     case TIFFTAG_JPEGRESTARTINTERVAL:
  704.         *va_arg(ap, u_short *) = td->td_jpegrestartinterval;
  705.         break;
  706.     case TIFFTAG_JPEGQTABLES:
  707.         *va_arg(ap, u_char ***) = td->td_qtab;
  708.         break;
  709.     case TIFFTAG_JPEGDCTABLES:
  710.         *va_arg(ap, u_char ***) = td->td_dctab;
  711.         break;
  712.     case TIFFTAG_JPEGACTABLES:
  713.         *va_arg(ap, u_char ***) = td->td_actab;
  714.         break;
  715. #endif
  716. #ifdef COLORIMETRY_SUPPORT
  717.     case TIFFTAG_WHITEPOINT:
  718.         *va_arg(ap, float **) = td->td_whitepoint;
  719.         break;
  720.     case TIFFTAG_PRIMARYCHROMATICITIES:
  721.         *va_arg(ap, float **) = td->td_primarychromas;
  722.         break;
  723.     case TIFFTAG_TRANSFERFUNCTION:
  724.         *va_arg(ap, u_short **) = td->td_transferfunction[0];
  725.         if (td->td_samplesperpixel - td->td_matteing > 1) {
  726.             *va_arg(ap, u_short **) = td->td_transferfunction[1];
  727.             *va_arg(ap, u_short **) = td->td_transferfunction[2];
  728.         }
  729.         break;
  730.     case TIFFTAG_REFERENCEBLACKWHITE:
  731.         *va_arg(ap, float **) = td->td_refblackwhite;
  732.         break;
  733. #endif
  734. #ifdef CMYK_SUPPORT
  735.     case TIFFTAG_INKSET:
  736.         *va_arg(ap, u_short *) = td->td_inkset;
  737.         break;
  738.     case TIFFTAG_DOTRANGE:
  739.         *va_arg(ap, u_short *) = td->td_dotrange[0];
  740.         *va_arg(ap, u_short *) = td->td_dotrange[1];
  741.         break;
  742.     case TIFFTAG_INKNAMES:
  743.         *va_arg(ap, char **) = td->td_inknames;
  744.         break;
  745.     case TIFFTAG_TARGETPRINTER:
  746.         *va_arg(ap, char **) = td->td_targetprinter;
  747.         break;
  748. #endif
  749.     default:
  750.         TIFFError("TIFFGetField1",
  751.             "Internal error, no value returned for tag \"%s\"",
  752.             TIFFFieldWithTag(tag)->field_name);
  753.         break;
  754.     }
  755.     va_end(ap);
  756. }
  757.  
  758. /*
  759.  * Return the value of a field in the
  760.  * internal directory structure.
  761.  */
  762. /*VARARGS2*/
  763. DECLARE2V(TIFFGetField, TIFF*, tif, u_int, tag)
  764. {
  765.     const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  766.  
  767.     if (fip) {
  768.         u_short bit = fip->field_bit;
  769.         if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
  770.             va_list ap;
  771.             VA_START(ap, tag);
  772.             (void) TIFFGetField1(&tif->tif_dir, tag, ap);
  773.             va_end(ap);
  774.             return (1);
  775.         }
  776.     } else
  777.         TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
  778.     return (0);
  779. }
  780.  
  781. /*
  782.  * Like TIFFGetField, but taking a varargs
  783.  * parameter list.  This routine is useful
  784.  * for building higher-level interfaces on
  785.  * top of the library.
  786.  */
  787. int
  788. DECLARE3(TIFFVGetField, TIFF*, tif, u_int, tag, va_list, ap)
  789. {
  790.     const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  791.  
  792.     if (fip) {
  793.         u_short bit = fip->field_bit;
  794.         if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
  795.             (void) TIFFGetField1(&tif->tif_dir, tag, ap);
  796.             return (1);
  797.         }
  798.     } else
  799.         TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
  800.     return (0);
  801. }
  802.  
  803. /*
  804.  * Internal interface to TIFFGetField...
  805.  */
  806. int
  807. /*VARARGS2*/
  808. DECLARE2V(_TIFFgetfield, TIFFDirectory*, td, u_int, tag)
  809. {
  810.     va_list ap;
  811.  
  812.     VA_START(ap, tag);
  813.     (void) TIFFGetField1(td, tag, ap);
  814.     va_end(ap);
  815. }
  816.  
  817. #define    CleanupField(member) {        \
  818.     if (td->member) {            \
  819.     _TIFFfree((char *)td->member);    \
  820.     td->member = 0;            \
  821.     }                    \
  822. }
  823.  
  824. /*
  825.  * Release storage associated with a directory.
  826.  */
  827. void
  828. DECLARE1(TIFFFreeDirectory, TIFF*, tif)
  829. {
  830.     register TIFFDirectory *td = &tif->tif_dir;
  831.  
  832.     CleanupField(td_colormap[0]);
  833.     CleanupField(td_colormap[1]);
  834.     CleanupField(td_colormap[2]);
  835.     CleanupField(td_documentname);
  836.     CleanupField(td_artist);
  837.     CleanupField(td_datetime);
  838.     CleanupField(td_hostcomputer);
  839.     CleanupField(td_imagedescription);
  840.     CleanupField(td_make);
  841.     CleanupField(td_model);
  842.     CleanupField(td_software);
  843.     CleanupField(td_pagename);
  844. #ifdef YCBCR_SUPPORT
  845.     CleanupField(td_ycbcrcoeffs);
  846. #endif
  847. #ifdef JPEG_SUPPORT
  848.     CleanupField(td_qtab);
  849.     CleanupField(td_dctab);
  850.     CleanupField(td_actab);
  851. #endif
  852. #ifdef CMYK_SUPPORT
  853.     CleanupField(td_inknames);
  854.     CleanupField(td_targetprinter);
  855. #endif
  856. #ifdef COLORIMETRY_SUPPORT
  857.     CleanupField(td_whitepoint);
  858.     CleanupField(td_primarychromas);
  859.     CleanupField(td_refblackwhite);
  860.     CleanupField(td_transferfunction[0]);
  861.     CleanupField(td_transferfunction[1]);
  862.     CleanupField(td_transferfunction[2]);
  863. #endif
  864.     CleanupField(td_stripoffset);
  865.     CleanupField(td_stripbytecount);
  866. }
  867. #undef CleanupField
  868.  
  869. /*
  870.  * Setup a default directory structure.
  871.  */
  872. int
  873. DECLARE1(TIFFDefaultDirectory, TIFF*, tif)
  874. {
  875.     register TIFFDirectory *td = &tif->tif_dir;
  876.  
  877.     memset(td, 0, sizeof (*td));
  878.     td->td_fillorder = FILLORDER_MSB2LSB;
  879.     td->td_bitspersample = 1;
  880.     td->td_threshholding = THRESHHOLD_BILEVEL;
  881.     td->td_orientation = ORIENTATION_TOPLEFT;
  882.     td->td_samplesperpixel = 1;
  883.     td->td_predictor = 1;
  884.     td->td_rowsperstrip = 0xffffffff;
  885.     td->td_tilewidth = 0xffffffff;
  886.     td->td_tilelength = 0xffffffff;
  887.     td->td_tiledepth = 1;
  888.     td->td_resolutionunit = RESUNIT_INCH;
  889.     td->td_sampleformat = SAMPLEFORMAT_VOID;
  890.     td->td_imagedepth = 1;
  891. #ifdef YCBCR_SUPPORT
  892.     td->td_ycbcrsubsampling[0] = 2;
  893.     td->td_ycbcrsubsampling[1] = 2;
  894.     td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
  895. #endif
  896. #ifdef CMYK_SUPPORT
  897.     td->td_inkset = INKSET_CMYK;
  898. #endif
  899.     (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  900.     /*
  901.      * NB: The directory is marked dirty as a result of setting
  902.      * up the default compression scheme.  However, this really
  903.      * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
  904.      * if the user does something.  We could just do the setup
  905.      * by hand, but it seems better to use the normal mechanism
  906.      * (i.e. TIFFSetField).
  907.      */
  908.     tif->tif_flags &= ~TIFF_DIRTYDIRECT;
  909.     return (1);
  910. }
  911.  
  912. /*
  913.  * Set the n-th directory as the current directory.
  914.  * NB: Directories are numbered starting at 0.
  915.  */
  916. int
  917. DECLARE2(TIFFSetDirectory, TIFF*, tif, int, dirn)
  918. {
  919.     static const char module[] = "TIFFSetDirectory";
  920.     u_short dircount;
  921.     long nextdir;
  922.     int n;
  923.  
  924.     nextdir = tif->tif_header.tiff_diroff;
  925.     for (n = dirn; n > 0 && nextdir != 0; n--) {
  926.         if (!SeekOK(tif, nextdir) ||
  927.             !ReadOK(tif, &dircount, sizeof (dircount))) {
  928.             TIFFError(module, "%s: Error fetching directory count",
  929.                 tif->tif_name);
  930.             return (0);
  931.         }
  932.         if (tif->tif_flags & TIFF_SWAB)
  933.             TIFFSwabShort(&dircount);
  934.         TIFFSeekFile(tif, dircount*sizeof (TIFFDirEntry), L_INCR);
  935.         if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
  936.             TIFFError(module, "%s: Error fetching directory link",
  937.                 tif->tif_name);
  938.             return (0);
  939.         }
  940.         if (tif->tif_flags & TIFF_SWAB)
  941.             TIFFSwabLong((u_long *)&nextdir);
  942.     }
  943.     tif->tif_nextdiroff = nextdir;
  944.     /*
  945.      * Set curdir to the actual directory index.  The
  946.      * -1 is because TIFFReadDirectory will increment
  947.      * tif_curdir after successfully reading the directory.
  948.      */
  949.     tif->tif_curdir = (dirn - n) - 1;
  950.     return (TIFFReadDirectory(tif));
  951. }
  952.  
  953. /*
  954.  * Return an indication of whether or not we are
  955.  * at the last directory in the file.
  956.  */
  957. int
  958. DECLARE1(TIFFLastDirectory, TIFF*, tif)
  959. {
  960.     return (tif->tif_nextdiroff == 0);
  961. }
  962.